import { useState } from 'react';
import { Button, Modal, Upload, message, Result } from 'antd';
import { UploadOutlined, FileTextOutlined, LoadingOutlined } from '@ant-design/icons';
import { useMessage } from '@/hooks/useMessage';
import { uploadFile, saveDocMessage } from '@/apis/file';
import { convertDocToTiptap } from '@/utils/docToTiptapConverter';
import { getUserId } from '@/utils/token';
import { useParams, useNavigate } from 'react-router-dom';
import './index.model.less';

const ImportDocument = ({
    onSuccess, // 导入成功后的回调
    onError,   // 导入失败后的回调
    folderId = '', // 文件夹ID
    buttonText = '导入文档', // 按钮文本
    buttonProps = {}, // 按钮属性
    modalTitle = '导入文档', // 模态框标题
    acceptTypes = '.doc,.docx,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document', // 接受的文件类型
    maxSize = 10, // 最大文件大小（MB）
    maxCount = 1, // 最大文件数量
}) => {
    const { success, error, contextHolder } = useMessage();
    const param = useParams();
    const navigate = useNavigate();
    const [modalVisible, setModalVisible] = useState(false);
    const [uploadLoading, setUploadLoading] = useState(false);
    const [fileList, setFileList] = useState([]);

    // 文件上传前的验证
    const beforeUpload = (file) => {
        const isDoc = file.type === 'application/msword' ||
            file.type === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' ||
            file.name.endsWith('.doc') ||
            file.name.endsWith('.docx');

        if (!isDoc) {
            error({
                content: '只能上传 Word 文档文件 (.doc, .docx)！'
            });
            return false;
        }

        const isLtMaxSize = file.size / 1024 / 1024 < maxSize;
        if (!isLtMaxSize) {
            error({
                content: `文件大小不能超过 ${maxSize}MB！`
            });
            return false;
        }

        return true;
    };

    // 处理DOC文件的函数 - 与UploadFile组件相同的逻辑
    const handleDocFile = async (file) => {
        try {
            // 转换DOC文件为Tiptap JSON格式
            const tiptapJson = await convertDocToTiptap(file)

            // 调试：打印转换后的内容
            console.log('转换后的Tiptap JSON:', tiptapJson)

            // 确保内容格式正确
            if (!tiptapJson || !tiptapJson.content || !Array.isArray(tiptapJson.content)) {
                throw new Error('文档转换失败：内容格式不正确')
            }

            // 如果内容为空，添加一个默认段落
            if (tiptapJson.content.length === 0) {
                tiptapJson.content = [
                    {
                        type: "paragraph",
                        attrs: { textAlign: null },
                        content: [{ type: "text", text: "文档内容" }]
                    }
                ]
            }

            // 获取用户ID
            const userId = getUserId()
            if (!userId) {
                throw new Error('用户未登录')
            }

            // 从文件名中提取文档名称（去掉扩展名）
            const docName = file.name.replace(/\.(doc|docx)$/i, '')

            // 准备保存文档的数据
            const docData = {
                docName: docName,
                userId: userId,
                docContent: JSON.stringify(tiptapJson), // 将对象转换为JSON字符串
                isBelongToKnowledgeBase: param.id ? "1" : "0", // 如果有知识库ID，则归属于知识库
                knowledgeBaseId: param.id || null
            }
            // 调用保存文档接口
            const response = await saveDocMessage(docData)

            if (response.code !== 200) {
                throw new Error(response.msg || '保存文档失败')
            }
            return response;

        } catch (error) {
            console.error('处理DOC文件失败:', error)
            throw error
        }
    }

    // 处理文件上传 - 与UploadFile组件相同的逻辑
    const handleUpload = async (file) => {
        if (!beforeUpload(file)) {
            return false;
        }

        setUploadLoading(true);
        try {
            // 检查文件类型
            const isDocFile = file.name.toLowerCase().endsWith('.doc') || file.name.toLowerCase().endsWith('.docx')

            if (isDocFile) {
                // 处理DOC文件
                await handleDocFile(file)
            } else {
                // 处理其他文件类型
                let id = ''
                if (param.id !== undefined) id = param.id
                await uploadFile({ id, file });
            }

            success({
                content: isDocFile ? '文档导入成功' : '上传文件成功',
                callBack: () => {
                    setUploadLoading(false);
                    setModalVisible(false);
                    setFileList([]);

                    // 调用成功回调
                    if (onSuccess) {
                        onSuccess({
                            file,
                            isDocFile
                        });
                    }

                    // 检查是否在知识库页面：通过检查是否有知识库ID和文档ID来判断
                    if (param.id && param.docId) {
                        // 在知识库详情页，跳转到知识库详细页，让侧边栏自动选择第一个文档
                        navigate(`/knowledgeBase/${param.id}/docDetail`, {
                            state: {
                                refresh: Date.now(),
                                refreshDocList: Date.now() // 触发文档列表刷新
                            }
                        })
                    } else if (param.id && !param.docId) {
                        // 在知识库列表页，跳转到知识库列表页
                        navigate(`/knowledgeBase/${param.id}`, {
                            state: {
                                refresh: Date.now(),
                                refreshDocList: Date.now() // 触发文档列表刷新
                            }
                        })
                    } else {
                        // 跳转到文档详情页
                        navigate(`/docList/docDetail/${newDocId}`, { state: { refresh: Date.now() } })
                    }
                }
            });
        } catch (e) {
            if (e.response?.data?.message === '文件已存在，请重新命名或选择其他文件夹上传') {
                error({
                    content: '文件已存在，请重新命名或选择其他文件夹上传',
                    callBack: () => setUploadLoading(false)
                })
            } else {
                error({
                    content: isDocFile ? '文档导入失败' : '上传文件失败',
                    callBack: () => setUploadLoading(false)
                })
            }

            // 调用错误回调
            if (onError) {
                onError(e);
            }
        }

        return false; // 阻止默认上传行为
    };

    // 处理文件列表变化
    const handleFileListChange = ({ fileList: newFileList }) => {
        setFileList(newFileList);
    };

    // 打开模态框
    const openModal = () => {
        setModalVisible(true);
    };

    // 关闭模态框
    const closeModal = () => {
        setModalVisible(false);
        setFileList([]);
    };


    // 上传模态框
    const UploadModal = () => (
        <Modal
            title={modalTitle}
            open={modalVisible}
            onCancel={closeModal}
            footer={null}
            width={500}
        >
            <div className="uploadModalArea">
                {uploadLoading ? (
                    <div className="uploadLoading">
                        <Result
                            icon={<LoadingOutlined />}
                            title='系统正在处理文件，请稍等'
                            status='info'
                        />
                    </div>
                ) : (
                    <Upload
                        fileList={fileList}
                        beforeUpload={handleUpload}
                        onChange={handleFileListChange}
                        accept={acceptTypes}
                        maxCount={maxCount}
                        showUploadList={{
                            showPreviewIcon: false,
                            showRemoveIcon: true,
                        }}
                    >
                        <Button
                            icon={<UploadOutlined />}
                            size="large"
                            loading={uploadLoading}
                            className="uploadButtonArea"
                        >
                            <div className="uploadButtonIcon">
                                <FileTextOutlined />
                            </div>
                            <div className="uploadButtonText">
                                点击或拖拽文件到此区域上传
                            </div>
                            <div className="uploadButtonHint">
                                支持 .doc, .docx 格式，文件大小不超过 {maxSize}MB
                            </div>
                        </Button>
                    </Upload>
                )}
            </div>
        </Modal>
    );


    return (
        <>
            {contextHolder}
            <Button
                onClick={openModal}
                icon={<UploadOutlined />}
                {...buttonProps}
            >
                {buttonText}
            </Button>
            <UploadModal />
        </>
    );
};

export default ImportDocument;